import { electronApp, optimizer } from '@electron-toolkit/utils';
import { app, BrowserWindow, globalShortcut } from 'electron';

import { ElectronAppEvents } from '../types';
import { config } from './config';
import { eventBus } from './eventbus';
import { log } from './logger';
import { initializeServerModules } from './server';
import themeManager from './theme';
import trayManager from './tray';
import userManager from './user';
import windowManager from './window';

/**
 * 应用管理器
 * 负责应用的创建、初始化和退出逻辑
 */
class AppManager {
  private isInitialized = false;
  private isShuttingDown = false;

  /**
   * 初始化应用
   */
  async initialize(): Promise<void> {
    try {
      // 确保应用单例运行
      if (!app.requestSingleInstanceLock()) {
        log.info('应用已在运行，退出当前实例');
        app.quit();
        process.exit(0);
      }

      // 设置应用事件监听
      this.setupAppEvents();

      // 等待应用准备就绪
      await app.whenReady();

      // 执行初始化
      await this.onReady();

      this.isInitialized = true;
      log.info('应用初始化完成');
    } catch (error) {
      log.error('应用初始化失败:', error);
      throw error;
    }
  }

  /**
   * 应用准备就绪时的初始化逻辑
   */
  private async onReady(): Promise<void> {
    // 设置应用用户模型ID
    electronApp.setAppUserModelId(import.meta.env.VITE_MAIN_BUNDLE_ID || 'com.coobee.JoythinkAi');

    // 注册事件消费者
    eventBus.initConsumers();

    // 清理用户锁文件（应用启动时）
    await userManager.cleanupLocks();

    // 初始化用户系统
    await userManager.initUsers();

    // 设置开发工具和快捷键
    this.setupDevelopmentFeatures();

    // 创建主窗口
    windowManager.createMainWindow();

    // 根据配置决定是否初始化托盘
    if (config.getShowTrayIcon()) {
      trayManager.createTray();
      log.info('根据配置启用了托盘图标');
    } else {
      log.info('根据配置禁用了托盘图标');
    }

    // 应用配置
    this.applyConfig();

    // 初始化服务器模块
    await initializeServerModules();

    log.info('应用核心组件初始化完成');
  }

  /**
   * 应用配置
   */
  private applyConfig(): void {
    // 设置主题
    const theme = config.getTheme();
    themeManager.setTheme(theme);

    // 设置窗口置顶
    const alwaysOnTop = config.getAlwaysOnTop();
    windowManager.setAlwaysOnTop(alwaysOnTop);
  }

  /**
   * 设置开发环境特性
   */
  private setupDevelopmentFeatures(): void {
    // 开发环境下启用F12开发者工具，生产环境忽略Ctrl+R刷新
    app.on(ElectronAppEvents.BROWSER_WINDOW_CREATED, (_, window) => {
      optimizer.watchWindowShortcuts(window);
    });

    // 注册全局快捷键（开发模式下）
    if (process.env.NODE_ENV === 'development') {
      log.info('开发模式已启用');
    }
  }

  /**
   * 设置应用事件监听
   */
  private setupAppEvents(): void {
    // macOS：点击Dock图标时重新创建窗口或显示现有窗口
    app.on(ElectronAppEvents.ACTIVATE, () => {
      if (BrowserWindow.getAllWindows().length === 0) {
        windowManager.createMainWindow();
      } else {
        windowManager.show();
      }
    });

    // 应用退出前清理资源
    app.on(ElectronAppEvents.BEFORE_QUIT, () => {
      this.cleanup();
    });

    // 所有窗口关闭时退出应用（macOS除外）
    app.on(ElectronAppEvents.WINDOW_ALL_CLOSED, () => {
      if (process.platform !== 'darwin') {
        this.quit();
      }
    });

    // 第二个实例启动时的处理
    app.on(ElectronAppEvents.SECOND_INSTANCE, () => {
      // 如果用户试图运行第二个实例，聚焦到主窗口
      if (BrowserWindow.getAllWindows().length > 0) {
        windowManager.show();
      } else {
        windowManager.createMainWindow();
      }
    });

    // 处理渲染进程崩溃
    app.on(ElectronAppEvents.RENDER_PROCESS_GONE, (_event, _webContents, details) => {
      log.error('渲染进程崩溃:', details);
      // 可以在这里添加崩溃恢复逻辑
    });

    // 处理子进程崩溃
    app.on(ElectronAppEvents.CHILD_PROCESS_GONE, (_event, details) => {
      log.error('子进程崩溃:', details);
    });
  }

  /**
   * 优雅退出应用
   */
  quit(): void {
    if (this.isShuttingDown) {
      return;
    }

    log.info('开始优雅退出应用...');
    this.isShuttingDown = true;
    app.quit();
  }

  /**
   * 清理应用资源
   */
  private cleanup(): void {
    if (!this.isInitialized) {
      return;
    }

    log.info('开始清理应用资源...');

    try {
      // 清理全局快捷键
      globalShortcut.unregisterAll();

      // 清理用户锁文件
      userManager.cleanupLocks();

      // 销毁托盘
      trayManager.destroy();

      // 可以在这里添加其他清理逻辑
      // 例如：关闭数据库连接、保存用户数据等

      log.info('应用资源清理完成');
    } catch (error) {
      log.error('清理应用资源时出错:', error);
    }

    // 开发模式下确保完全退出
    if (process.env.NODE_ENV === 'development') {
      this.killProcessTree();
    }
  }

  /**
   * 获取应用状态
   */
  getStatus(): {
    isInitialized: boolean;
    isShuttingDown: boolean;
    isReady: boolean;
  } {
    return {
      isInitialized: this.isInitialized,
      isShuttingDown: this.isShuttingDown,
      isReady: app.isReady()
    };
  }

  /**
   * 重启应用
   */
  restart(): void {
    log.info('重启应用...');
    app.relaunch();
    this.quit();
  }

  /**
   * 杀死进程树（开发模式专用）
   * 确保包括 concurrently 在内的所有相关进程都被终止
   */
  private killProcessTree(): void {
    try {
      if (process.platform === 'win32') {
        // Windows 下杀死进程树
        const { exec } = require('child_process');
        const parentPid = process.ppid;

        log.info(`正在杀死 Windows 进程树，父进程 PID: ${parentPid}`);

        // 使用 taskkill 命令杀死整个进程树
        exec(`taskkill /pid ${parentPid} /T /F`, (error: any) => {
          if (error) {
            log.warn('杀死父进程失败，尝试直接退出:', error.message);
          } else {
            log.info('成功杀死父进程树');
          }
          // 无论是否成功，都强制退出当前进程
          process.exit(0);
        });

        // 设置超时，防止卡死
        setTimeout(() => {
          log.warn('杀死进程树超时，强制退出');
          process.exit(0);
        }, 1000);
      } else {
        // Unix 系统（macOS/Linux）下杀死进程组
        const parentPid = process.ppid;

        log.info(`正在杀死 Unix 进程组，父进程 PID: ${parentPid}`);

        try {
          // 尝试杀死父进程组
          process.kill(-parentPid, 'SIGTERM');
          log.info('发送 SIGTERM 信号到父进程组');

          // 等待一段时间后强制杀死
          setTimeout(() => {
            try {
              process.kill(-parentPid, 'SIGKILL');
              log.info('发送 SIGKILL 信号到父进程组');
            } catch (killError) {
              log.warn('发送 SIGKILL 失败:', killError);
            }
            process.exit(0);
          }, 500);
        } catch (termError) {
          log.warn('发送 SIGTERM 失败，直接退出:', termError);
          process.exit(0);
        }
      }
    } catch (error) {
      log.error('杀死进程树时发生错误，回退到普通退出:', error);
      process.exit(0);
    }
  }
}

// 创建单例实例
const appManager = new AppManager();

// 默认导出
export default appManager;
